home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 1 / LSD Compendium Deluxe 1.iso / a / programming / assemblers / cas.lha / io.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-14  |  20.4 KB  |  672 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #include <stdarg.h>
  6. #include "io.h"
  7. #include "op.h"
  8.  
  9. extern int Active;
  10.  
  11. /* SKIP LISTS are used to implement the symbol table */
  12.  
  13. char *CopyS(char *S) {
  14.    char *NewS;
  15.    if (S == 0) return 0;
  16.    NewS = Allocate(strlen(S) + 1);
  17.    strcpy(NewS, S);
  18.    return NewS;
  19. }
  20.  
  21. int CompS(char *A, char *B) {
  22.    if (A == 0) return (B == 0)? 0: +1;
  23.    if (B == 0) return -1;
  24.    for (; *A != '\0'; A++, B++) {
  25.       int Diff = tolower(*A) - tolower(*B);
  26.       if (Diff < 0) return -1;
  27.       if (Diff > 0) return +1;
  28.    }
  29.    return (*B == '\0')? 0: -1;
  30. }
  31.  
  32. static int Random(void) {
  33.    static byte B = 0, X = 0;
  34.    register int L = 0, D;
  35.    while (1) {
  36.       if (X == 0) X = 4, B = rand()&0xff;
  37.       D = B&3, B >>= 2, X--;
  38.       if (D) return L;
  39.       L++;
  40.    }
  41. }
  42.  
  43. #define MAX_BREADTH 16
  44. Symbol NIL;
  45. static Symbol Path[MAX_BREADTH];
  46. static int Breadth;
  47.  
  48. static Symbol Form(int B, char *Name) {
  49.    Symbol N = (Symbol)malloc(sizeof *N + B*sizeof(Symbol));
  50.    if (N == 0) fprintf(stderr, "Out of memory.\n"), exit(1);
  51.    N->Name = CopyS(Name),
  52.    N->Defined = N->Global = N->Variable = N->Address = N->Map = 0;
  53.    return N;
  54. }
  55.  
  56. #include <sys/types.h>
  57. /* #include <sys/timeb.h> */
  58.  
  59. void SymInit(void) {
  60. /*   struct timeb T;*/ int K;
  61. /*   ftime(&T); srand((unsigned int)(T.time ^ T.millitm)&0xffff);*/
  62.    NIL = Form(MAX_BREADTH - 1, 0);
  63.    for (K = 0; K < MAX_BREADTH; K++) NIL->Next[K] = NIL;
  64.    Breadth = 0;
  65. }
  66.  
  67. int Next, Value;
  68. int Line, StartLine;
  69.  
  70. Symbol LookUp(char *Name) {
  71.    int K/*, B*/; Symbol P, Q;
  72.    if (!Active) return 0;
  73.    for (K = Breadth, P = NIL; K >= 0; K--) {
  74.       Q = P->Next[K];
  75.       while (CompS(Q->Name, Name) < 0) P = Q, Q = Q->Next[K];
  76.       Path[K] = P;
  77.    }
  78.    if (CompS(Q->Name, Name) == 0) return Q;
  79.    K = Random(); if (K > Breadth) K = ++Breadth, Path[K] = NIL;
  80.    Q = Form(K, Name);
  81.    for (; K >= 0; K--) Q->Next[K] = Path[K]->Next[K], Path[K]->Next[K] = Q;
  82.    return Q;
  83. }
  84.  
  85. #define LINE_MAX 200
  86. char Text[LINE_MAX]; static char *U;
  87.  
  88. #define INCLUDE_MAX 5
  89. struct {
  90.    word Path; long Loc; int Next, Line;
  91. } IS[INCLUDE_MAX], *ISP;
  92. static FILE *InF; 
  93. extern FILE *OutF; /* 'extern' by caro - see link.c */
  94. char **FileTab; long Files;
  95. int StartF, CurF;
  96. static int FileMax;
  97.  
  98. void FileInit(void) {
  99.    ISP = IS - 1, FileTab = 0, Files = 0, FileMax = 0;
  100. }
  101.  
  102. static byte ERRORS = 0;
  103. char InSeg = 0;
  104. void ERROR(const char *Format, ...) {
  105.    va_list AP;
  106.    if (InSeg) printf("%s: [%d] ", FileTab[StartF], StartLine);
  107.    va_start(AP, Format);
  108.    vprintf(Format, AP); putchar('\n');
  109.    va_end(AP);
  110.    if (++ERRORS >= 24) printf("Too many errors.  Aborting.\n"), exit(1);
  111. } 
  112.  
  113. void FATAL(const char *Format, ...) {
  114.    va_list AP;
  115.    if (InSeg) printf("%s: [%d] ", FileTab[StartF], StartLine);
  116.    va_start(AP, Format);
  117.    vprintf(Format, AP); putchar('\n');
  118.    va_end(AP);
  119.    exit(1);
  120. }
  121.  
  122. void CHECK(void) {
  123.    if (ERRORS > 0) printf("Errors present.  Assembly stopped.\n"), exit(1);
  124. }
  125.  
  126. byte GetB(FILE *FP) {
  127.    int A;
  128.    A = fgetc(FP); if (A == EOF) FATAL("Unexpected EOF.");
  129.    return ((byte)(A&0xff));
  130. }
  131.  
  132. word GetW(FILE *FP) {
  133.    int A, B;
  134.    A = fgetc(FP); if (A == EOF) FATAL("Unexpected EOF.");
  135.    B = fgetc(FP); if (B == EOF) FATAL("Unexpected EOF.");
  136.    return ((word)((A&0xff) << 8 | B&0xff));
  137. }
  138.  
  139. unsigned long GetL(FILE *FP) {
  140.    int A, B, C, D;
  141.    A = fgetc(FP); if (A == EOF) FATAL("Unexpected EOF.");
  142.    B = fgetc(FP); if (B == EOF) FATAL("Unexpected EOF.");
  143.    C = fgetc(FP); if (C == EOF) FATAL("Unexpected EOF.");
  144.    D = fgetc(FP); if (D == EOF) FATAL("Unexpected EOF.");
  145.    return ((unsigned long)((A&0xff) << 24 | (B&0xff) << 16 | (C&0xff) << 8 | D&0xff));
  146. }
  147.  
  148. void PutB(byte B, FILE *FP) { fputc(B, FP); }
  149.  
  150. void PutW(word W, FILE *FP) {
  151.    char A = (W >> 8)&0xff, B = W&0xff;
  152.    fputc(A, FP), fputc(B, FP);
  153. }
  154.  
  155. void PutL(unsigned long L, FILE *FP) {
  156.    char A = (L >> 24)&0xff, B = (L >> 16)&0xff, C = (L >> 8)&0xff, D = L&0xff;
  157.    fputc(A, FP), fputc(B, FP), fputc(C, FP), fputc(D, FP);
  158. }
  159.  
  160. void *Allocate(unsigned Size) {
  161.    void *X;
  162.    if (Size == 0) return 0;
  163.    X = malloc(Size); if (X == 0) FATAL("Out of memory.");
  164.    return X;
  165. }
  166.  
  167. void OpenF(char *Name) {
  168.    if (!Active) return;
  169.    if (ISP >= IS + INCLUDE_MAX - 1) FATAL("Too many nested include files.");
  170.    if (ISP >= IS) {
  171.       ISP->Loc = ftell(InF);
  172.       if (ISP->Loc == -1L)
  173.          FATAL("Could not save %s's position.", FileTab[CurF]);
  174.       fclose(InF);
  175.       ISP->Next = Next, ISP->Line = Line, ISP->Path = CurF;
  176.    }
  177.    if (Files >= FileMax) {
  178.       FileMax += 4;
  179.       FileTab = (char **)realloc(FileTab, FileMax * sizeof *FileTab);
  180.       if (FileTab == 0) FATAL("Out of memory.");
  181.    }
  182.    ISP++, CurF = Files, FileTab[Files++] = CopyS(Name);
  183.    StartLine = Line = 1;
  184.    InF = fopen(Name, "r");
  185.    if (InF == 0) FATAL("Cannot open %s", Name);
  186.    Next = fgetc(InF);
  187. }
  188.  
  189. #define SEG_MAX 0x20
  190. struct Segment SegTab[SEG_MAX], *SegP;
  191. unsigned long LOC;
  192.  
  193. #define GAP_MAX 0x100
  194. struct Gap GapTab[GAP_MAX], *GapP;
  195.  
  196. struct AddrCard AddrTab[TYPES] = {
  197.    { 0, 0xffff, 1 },  /* CODE */
  198.    { 0, 0xffff, 0 },  /* XDATA */
  199.    { 0, 0xff, 0 },    /* DATA */
  200.    { 0x80, 0xff, 0 }, /* SFR */
  201.    { 0, 0xff, 0 }     /* BIT */
  202. };
  203. static struct AddrCard *AdP;
  204.  
  205. Symbol Sym;
  206.  
  207. static Symbol BTab[10], FTab[10];
  208. static Symbol MakeLabel(void) {
  209.    static unsigned long LAB = 0L; static char Buf[10];
  210.    sprintf(Buf, "#%x", LAB++);
  211.    return LookUp(Buf);
  212. }
  213.  
  214. void SegInit(void) {
  215.    int I, D;
  216.    for (SegP = SegTab, AdP = AddrTab, I = 0; I < TYPES; AdP++, I++, SegP++) {
  217.       if (SegP >= SegTab + SEG_MAX) FATAL("Too many segments.");
  218.       SegP->Type = I, SegP->Rel;
  219.       SegP->Base = 0, SegP->Size = 0, SegP->Loc = ftell(OutF);
  220.    }
  221.    AdP = AddrTab; InSeg = 1;
  222.    SegP->Type = 0, SegP->Rel = 1,
  223.    SegP->Line = StartLine, SegP->File = StartF,
  224.    SegP->Base = 0, SegP->Size = 0, SegP->Loc = ftell(OutF);
  225.    LOC = 0;
  226.    for (D = 0; D < 10; D++) BTab[0] = FTab[0] = 0;
  227.    GapP = GapTab;
  228. }
  229.  
  230. void StartSeg(byte Type, byte Rel, word Base) {
  231.    int D;
  232.    if (!Active) return;
  233.    if (SegP >= SegTab + SEG_MAX) FATAL("Too many segments.");
  234.    if (Type > sizeof AddrTab/sizeof *AddrTab)
  235.       FATAL("Undefined segment type.");
  236.    AdP = AddrTab + Type;
  237.    if (!Rel && (Base < AdP->Lo || Base > AdP->Hi))
  238.       FATAL("Address %u out of range", Base);
  239.    InSeg = 1;
  240.    SegP->Type = Type, SegP->Rel = Rel,
  241.    SegP->Line = StartLine, SegP->File = StartF,
  242.    SegP->Base = Base, SegP->Size = 0, SegP->Loc = ftell(OutF);
  243.    LOC = 0;
  244.    for (D = 0; D < 10; D++) BTab[0] = FTab[0] = 0;
  245. }
  246.  
  247. void EndSeg(void) {
  248.    int D;
  249.    if (!Active) return;
  250.    for (D = 0; D < 10; D++)
  251.       if (FTab[D] != 0) ERROR("Undefined label %d", D);
  252.    SegP->Size = (word)LOC;
  253.    if (SegP->Size > 0) SegP++;
  254.    InSeg = 0;
  255. }
  256.  
  257. void PByte(byte B) {
  258.    unsigned long Addr;
  259.    if (!Active) return;
  260.    if (!AdP->ReadOnly) FATAL("Attempting to write to a non-code segment.");
  261.    LOC++; Addr = SegP->Base + LOC;
  262.    if (!SegP->Rel && Addr > AdP->Hi + 1) FATAL("Address %u out of range", Addr);
  263.    fputc(B, OutF);
  264. }
  265.  
  266. void PString(char *S) {
  267.    if (!Active) return;
  268.    for (; *S != '\0'; S++) PByte(*S);
  269. }
  270.  
  271. void Space(word Rel) {
  272.    unsigned long Addr;
  273.    if (!Active) return;
  274.    if (AdP->ReadOnly) {
  275.       if (GapP >= GapTab + GAP_MAX) FATAL("Too many gaps.");
  276.       GapP->Seg = SegP, GapP->Offset = LOC, GapP->Size = Rel;
  277.       GapP++;
  278.    }
  279.    LOC += Rel;
  280.    Addr = SegP->Base + LOC;
  281.    if (!SegP->Rel && Addr > AdP->Hi + 1) FATAL("Address %u out of range", Addr);
  282. }
  283.  
  284. /* A hasty bug fix: accounts for the fact that the memory images stored in
  285.    files exclude gaps.
  286.  */
  287. long SegTell(Segment Seg, word Offset) {
  288.    long L = Seg->Loc + Offset; Gap G;
  289.    for (G = GapTab; G < GapP; G++)
  290.       if (G->Seg == Seg && G->Offset < Offset) L -= G->Size;
  291.    return L;
  292. }
  293.  
  294. static void Get(void) {
  295.    /* int Ch; */
  296.    if (Next == EOF) {
  297.       while (Next == EOF && ISP > IS) {
  298.          fclose(InF); ISP--;
  299.          Next = ISP->Next, Line = ISP->Line, CurF = ISP->Path;
  300.          InF = fopen(FileTab[CurF], "r");
  301.          if (InF == 0) FATAL("Cannot reopen %s", FileTab[CurF]);
  302.          if (fseek(InF, ISP->Loc, SEEK_SET) != 0) {
  303.             fclose(InF);
  304.             FATAL("Could not restore %s's position.", FileTab[CurF]);
  305.          }
  306.       }
  307.       if (Next == EOF) fclose(InF), Next = 0;
  308.       *U++ = ' ';
  309.    } else {
  310.       if (Next == '\n') Line++;
  311.       *U++ = Next; Next = fgetc(InF);
  312.    }
  313. }
  314.  
  315. typedef struct {
  316.    char *Name; Lexical Tag; int Value;
  317. } Card;
  318. static Card Reserved[] = {
  319.    { "ds", RB, 0 }, { "rb", RB, 0 }, { "rw", RW, 0 },
  320.    { "byte", DB, 0 }, { "word", DW, 0 }, { "db", DB, 0 }, { "dw", DW, 0 },
  321.    { "seg", SEG, 0 }, { "end", END, 0 },
  322.    { "org", ORG, 0 }, { "at", ORG, 0 }, { "equ", EQU, 0 }, { "set", SET, 0 },
  323.    { "include", INCLUDE, 0 }, { "global", GLOBAL, 0 }, { "public", GLOBAL, 0 },
  324.    { "extern", EXTERN, 0 }, { "if", IF, 0 }, { "else", ELSE, 0 },
  325.    { "high", HIGH, 0 }, { "low", LOW, 0 }, { "by", BY, 0 },
  326.    { "code", TYPE, CODE }, { "xdata", TYPE, XDATA },
  327.    { "bit", TYPE, BIT }, { "sfr", TYPE, SFR }, { "data", TYPE, DATA },
  328.    { "a", REGISTER, ACC }, { "ab", REGISTER, AB }, { "c", REGISTER, CY },
  329.    { "dptr", REGISTER, DPTR }, { "pc", REGISTER, PC },
  330.    { "r0", REGISTER, R0 }, { "r1", REGISTER, R1 },
  331.    { "r2", REGISTER, R2 }, { "r3", REGISTER, R3 },
  332.    { "r4", REGISTER, R4 }, { "r5", REGISTER, R5 },
  333.    { "r6", REGISTER, R6 }, { "r7", REGISTER, R7 }
  334. };
  335.  
  336. #define ELEMENTS(Arr) (sizeof(Arr)/sizeof(Arr[0]))
  337.  
  338. static Lexical FindKey(char *Name) {
  339.    Code *CP; Card *C;
  340.    static Card *EndR = Reserved + ELEMENTS(Reserved);
  341.    for (CP = CodeTab; CP->Name != 0; CP++)
  342.       if (CompS(Name, CP->Name) == 0) {
  343.          Value = CP - CodeTab; return MNEMONIC;
  344.       }
  345.    for (C = Reserved; C < EndR; C++)
  346.       if (CompS(Name, C->Name) == 0) {
  347.          Value = C->Value; return C->Tag;
  348.       }
  349.    Sym = LookUp(Name);
  350.    return SYMBOL;
  351. }
  352.  
  353. typedef struct {
  354.    char *Name; byte Type; word Val;
  355. } ValCard;
  356. static ValCard ValTab[] = {
  357. /* Special function registers */
  358.    { "P0", SFR, 0x80 }, { "P1", SFR, 0x90 },
  359.    { "P2", SFR, 0xa0 }, { "P3", SFR, 0xb0 },
  360.    { "PCON", SFR, 0x87 }, { "TCON", SFR, 0x88 }, { "TMOD", SFR, 0x89 },
  361.    { "SCON", SFR, 0x98 }, { "SBUF", SFR, 0x99 },
  362.    { "IE",   SFR, 0xa8 }, { "IP",   SFR, 0xb8 },
  363.    { "TL0", SFR, 0x8a }, { "TL1", SFR, 0x8b },
  364.    { "TH0", SFR, 0x8c }, { "TH1", SFR, 0x8d },
  365.    { "SP",   SFR, 0x81 }, { "DPL",  SFR, 0x82 }, { "DPH",  SFR, 0x83 },
  366.    { "PSW",  SFR, 0xd0 }, { "ACC",  SFR, 0xe0 }, { "B",    SFR, 0xf0 },
  367. /* Special funcgtion register bits */
  368.    { "RI",  BIT, 0x98 }, { "TI",  BIT, 0x99 },    /* SCON */
  369.    { "RB8", BIT, 0x9a }, { "TB8", BIT, 0x9b },
  370.    { "REN", BIT, 0x9c }, { "SM2", BIT, 0x9d },
  371.    { "SM1", BIT, 0x9e }, { "SM0", BIT, 0x9f },
  372.    { "RXD",  BIT, 0xb0 }, { "TXD",  BIT, 0xb1 },  /* Port 3 */
  373.    { "INT0", BIT, 0xb2 }, { "INT1", BIT, 0xb3 },
  374.    { "T0",   BIT, 0xb4 }, { "T1",   BIT, 0xb5 },
  375.    { "WR",   BIT, 0xb6 }, { "RD",   BIT, 0xb7 },
  376.    { "P",   BIT, 0xd0 }, { "OV",  BIT, 0xd2 },    /* PSW */
  377.    { "RS0", BIT, 0xd3 }, { "RS1", BIT, 0xd4 },
  378.    { "F0",  BIT, 0xd5 }, { "AC",  BIT, 0xd6 }, { "CY",  BIT, 0xd7 },
  379.    { "IT0", BIT, 0x88 }, { "IE0", BIT, 0x89 },    /* TCON */
  380.    { "IT1", BIT, 0x8a }, { "IE1", BIT, 0x8b },
  381.    { "TR0", BIT, 0x8c }, { "TF0", BIT, 0x8d },
  382.    { "TR1", BIT, 0x8e }, { "TF1", BIT, 0x8f },
  383.    { "EX0", BIT, 0xa8 }, { "ET0", BIT, 0xa9 },    /* IE */
  384.    { "EX1", BIT, 0xaa }, { "ET1", BIT, 0xab },
  385.    { "ES",  BIT, 0xac }, { "EA",  BIT, 0xaf },
  386.    { "PX0", BIT, 0xb8 }, { "PT0", BIT, 0xb9 },    /* IP */
  387.    { "PX1", BIT, 0xba }, { "PT1", BIT, 0xbb }, { "PS",  BIT, 0xbc }
  388. };
  389.  
  390. void RegInit(void) {
  391.    ValCard *V; Symbol Sym;
  392.    static ValCard *EndV = ValTab + ELEMENTS(ValTab);
  393.    for (V = ValTab; V < EndV; V++) {
  394.       Sym = LookUp(V->Name);
  395.       Sym->Defined = Sym->Address = 1;
  396.       Sym->Seg = &SegTab[V->Type], Sym->Offset = V->Val;
  397.    }
  398. }
  399.  
  400. #define isoctal(Ch) (isdigit(Ch) && Ch < '8')
  401. #define isx(Ch) (tolower(Ch) == 'x' || tolower(Ch) == 'h')
  402. #define isq(Ch) (tolower(Ch) == 'q' || tolower(Ch) == 'o')
  403.  
  404. char InExp = 0, InSemi = 0;
  405. Lexical OldL;
  406. #define Ret(Token) return (*U = '\0', OldL = (Token))
  407.  
  408. Lexical Scan(void) {
  409.    char *S; int Bad;
  410. Start:
  411.    U = Text;
  412.    if (isalpha(Next) || Next == '_') {
  413.       while (isalnum(Next) || Next == '_') Get();
  414.       Ret(FindKey(Text));
  415.    } else if (isdigit(Next)) {
  416.       char Ch = Next; Get();
  417.       if (Ch == '0' && isx(Next)) {
  418.          do Get(); while (isxdigit(Next));
  419.          goto RetHex;
  420.       }
  421.       if (Next == ':' && !InExp) {
  422.          char D = *Text - '0';
  423.          if (Active) {
  424.             Sym = BTab[D] = (FTab[D] == 0)? MakeLabel(): FTab[D];
  425.             FTab[D] = 0;
  426.             Sym->Global = 0, Sym->Defined = Sym->Address = Sym->Variable = 1,
  427.             Sym->Seg = SegP, Sym->Offset = (word)LOC;
  428.          } else Sym = 0;
  429.          Ret(SYMBOL);
  430.       }
  431.       while (isxdigit(Next)) Get();
  432.       if (isx(Next)) { Get(); goto RetHex; }
  433.       if (isq(Next)) { Get(); goto RetOct; }
  434.       if (U - Text == 2) {
  435.          if (tolower(Text[1]) == 'b') {
  436.             char D = *Text - '0';
  437.             if (Active) {
  438.                Sym = BTab[D];
  439.                if (Sym == 0) {
  440.                   BTab[D] = Sym = MakeLabel();
  441.                   ERROR("Undefined local symbol %cb", D);
  442.                   Sym->Global = Sym->Defined = 0,
  443.                   Sym->Address = Sym->Variable = 1,
  444.                   Sym->Seg = SegP, Sym->Offset = 0;
  445.                }
  446.             } else Sym = 0;
  447.             Ret(SYMBOL);
  448.          } else if (tolower(Text[1]) == 'f') {
  449.             char D = *Text - '0';
  450.             if (Active) {
  451.                if (FTab[D] == 0) FTab[D] = MakeLabel();
  452.                Sym = FTab[D];
  453.             } else Sym = 0;
  454.             Ret(SYMBOL);
  455.          }
  456.       }
  457.       if (tolower(U[-1]) == 'b') goto RetBin;
  458.       if (tolower(U[-1]) == 'd' || *Text != '0') goto RetDec;
  459.       if (U == Text) { Value = 0; Ret(NUMBER); }
  460.       if (isx(Text[1])) goto RetHex;
  461.       if (tolower(Text[1]) == 'b') goto RetBin;
  462.       goto RetDec;
  463. RetBin:
  464.       S = Text;
  465.       if (tolower(U[-1]) == 'b') U--;
  466.       else if (U >= S + 2 && S[0] == '0' && tolower(S[1]) == 'b') S += 2;
  467.       for (Bad = 0, Value = 0; S < U; S++) {
  468.          int D = *S - '0';
  469.          if (!isdigit(*S) || D >= 2) Bad++, D = 0;
  470.          Value = (Value << 1) | D;
  471.       }
  472.       if (Bad) ERROR("Binary number has non-binary digits.");
  473.       Ret(NUMBER);
  474. RetOct:
  475.       if (isq(U[-1])) U--;
  476.       for (Bad = 0, Value = 0, S = Text; S < U; S++) {
  477.          int D = *S - '0';
  478.          if (!isdigit(*S) || D >= 010) Bad++, D = 0;
  479.          Value = (Value << 3) | D;
  480.       }
  481.       if (Bad) ERROR("Octal number has non-octal digits.");
  482.       Ret(NUMBER);
  483. RetDec:
  484.       if (tolower(U[-1]) == 'd') U--;
  485.       for (Bad = 0, Value = 0, S = Text; S < U; S++) {
  486.          int D = *S - '0';
  487.          if (!isdigit(*S)) Bad++, D = 0;
  488.          Value = 10*Value + D;
  489.       }
  490.       if (Bad) ERROR("Decimal number has non-decimal digits.");
  491.       Ret(NUMBER);
  492. RetHex:
  493.       S = Text;
  494.       if (isx(U[-1])) U--;
  495.       else if (U >= S + 2 && S[0] == '0' && isx(S[1])) S += 2;
  496.       for (Value = 0; S < U; S++) {
  497.          Value <<= 4, Value += isdigit(*S)? *S - '0': tolower(*S) - 'a' + 10;
  498.       }
  499.       Ret(NUMBER);
  500.    }
  501.    switch (Next) {
  502.       case ';': switch (Get(), Next) {
  503.          case ';':
  504.             while (Next != '\n') {
  505.                if (Next == EOF) FATAL("Unexpected EOF inside ;; comment.");
  506.                Next = fgetc(InF);
  507.             }
  508.             Get();
  509.             if (!InSemi) goto Start;
  510.          default: Ret(SEMI);
  511.       }
  512.       break;
  513.       case '/': switch (Get(), Next) {
  514.          case '/':
  515.             while (Next != '\n') {
  516.                if (Next == EOF) FATAL("Unexpected EOF inside // comment.");
  517.                Next = fgetc(InF);
  518.             }
  519.             Get();
  520.             if (!InSemi) goto Start;
  521.          Ret(SEMI);
  522.          case '*': {
  523.             int Line0 = Line;
  524.             Next = fgetc(InF);
  525.             while (Next != EOF) {
  526.                if (Next == '*') {
  527.                   while (Next == '*') Next = fgetc(InF);
  528.                   if (Next == '/') {
  529.                      Next = fgetc(InF);
  530.                      if (Line <= Line0 || !InSemi) goto Start;
  531.                      Ret(SEMI);
  532.                   }
  533.                } else {
  534.                   if (Next == '\n') Line++; Next = fgetc(InF);
  535.                }
  536.             }
  537.             FATAL("Unexpected EOF inside comment.");
  538.          }
  539.          default: Ret(DIV);
  540.       }
  541.       case '\'':
  542.      Get();
  543.          if (Next == '\'') {
  544.             ERROR("Empty character constant."); Get(); Value = 0; Ret(NUMBER);
  545.          }
  546.      if (Next == '\\') {
  547.             int I;
  548.         Get();
  549.         if (isoctal(Next)) {
  550.            for (Value = 0; isoctal(Next); Get())
  551.                   Value <<= 3, Value += Next - '0';
  552.         } else if (tolower(Next) == 'x') {
  553.            Get();
  554.                if (!isxdigit(Next)) {
  555.                   ERROR("Bad hexadecimal character.");
  556.                   Value = 'x';
  557.                } else for (I = 0; I < 2 && isxdigit(Next); I++, Get()) {
  558.                   Value <<= 4;
  559.                   Value += isdigit(Next)? Next - '0': tolower(Next) - 'a' + 10;
  560.                }
  561.         } else {
  562.                switch (Next) {
  563.                   case 'a': Value = 0x07; break;
  564.                   case 'b': Value = 0x08; break;
  565.                   case 't': Value = 0x09; break;
  566.                   case 'n': Value = 0x0a; break;
  567.                   case 'v': Value = 0x0b; break;
  568.                   case 'f': Value = 0x0c; break;
  569.                   case 'r': Value = 0x0d; break;
  570.                   default: Value = Next; break;
  571.                }
  572.                Get();
  573.             }
  574.      } else Value = Next, Get();
  575.      if (Next != '\'') ERROR("Missing a ' in character constant.");
  576.          else Get();
  577.       Ret(NUMBER);
  578.       case '"':
  579.          Next = fgetc(InF);
  580.          while (Next != '\"') {
  581.             if (Next == EOF) FATAL("Unexpected EOF inside string.");
  582.             else if (Next == '\\') {
  583.                Next = fgetc(InF);
  584.                if (Next == EOF) FATAL("Unexpected EOF inside string.");
  585.            if (isoctal(Next)) {
  586.                   char Value = 0;
  587.                   while (isoctal(Next)) {
  588.                      Value = (Value << 3) + (Next - '0');
  589.                      Next = fgetc(InF);
  590.                   }
  591.                   *U++ = Value;
  592.            } else if (tolower(Next) == 'x') {
  593.                   char Value;
  594.                   Next = fgetc(InF);
  595.                   if (!isxdigit(Next)) Value = 'x';
  596.           else while (isxdigit(Next)) {
  597.                      Value <<= 4;
  598.                      Value += isdigit(Next)? Next - '0': tolower(Next) - 'a' + 10;
  599.                      Next = fgetc(InF);
  600.                   }
  601.                   *U++ = Value;
  602.            } else {
  603.                   if (Next == '\n') Line++;
  604.                   switch (Next) {
  605.                      case 'a': *U++ = '\a'; break;
  606.                      case 'b': *U++ = '\b'; break;
  607.                      case 't': *U++ = '\t'; break;
  608.                      case 'n': *U++ = '\n'; break;
  609.                      case 'v': *U++ = '\v'; break;
  610.                      case 'f': *U++ = '\f'; break;
  611.                      case 'r': *U++ = '\r'; break;
  612.                      default: *U++ = Next; break;
  613.                   }
  614.                   Next = fgetc(InF);
  615.                }
  616.         } else {
  617.                if (Next == '\n') Line++;
  618.                *U++ = Next; Next = fgetc(InF);
  619.             }
  620.          }
  621.          Next = fgetc(InF);
  622.       Ret(STRING);
  623.       case '<': switch (Get(), Next) {
  624.      case '=': Get(); Ret(LE);
  625.      case '<': Get(); Ret(SHL);
  626.          default: Ret(LT);
  627.       }
  628.       case '>': switch (Get(), Next) {
  629.      case '=': Get(); Ret(GE);
  630.      case '>': Get(); Ret(SHR);
  631.      default: Ret(GT);
  632.       }
  633.       case '&': switch (Get(), Next) {
  634.      case '&': Get(); Ret(AND_AND);
  635.      default: Ret(AND);
  636.       }
  637.       case '|': switch (Get(), Next) {
  638.      case '|': Get(); Ret(OR_OR);
  639.      default: Ret(OR);
  640.       }
  641.       case '=': switch (Get(), Next) {
  642.      case '=': Get(); Ret(EQ);
  643.      default: Ret(SET);
  644.       }
  645.       case '!': switch (Get(), Next) {
  646.      case '=': Get(); Ret(NE);
  647.      default: Ret(NOT_NOT);
  648.       }
  649.       case '\n': Get(); if (!InSemi) goto Start; Ret(SEMI);
  650.       case '^': Get(); Ret(XOR);
  651.       case '+': Get(); Ret(PLUS);
  652.       case '-': Get(); Ret(MINUS);
  653.       case '*': Get(); Ret(MULT);
  654.       case '%': Get(); Ret(MOD);
  655.       case '@': Get(); Ret(AT);
  656.       case '#': Get(); Ret(POUND);
  657.       case '$': Get(); Ret(DOLLAR);
  658.       case '.': Get(); Ret(DOT);
  659.       case '~': Get(); Ret(NOT);
  660.       case ',': Get(); Ret(COMMA);
  661.       case ':': Get(); Ret(COLON);
  662.       case '?': Get(); Ret(QUEST);
  663.       case '{': Get(); Ret(LCURL);
  664.       case '}': Get(); Ret(RCURL);
  665.       case '(': Get(); Ret(LPAR);
  666.       case ')': Get(); Ret(RPAR);
  667.       case 0: Ret(0);
  668.       default: Get(); goto Start;
  669.    }
  670. }
  671.  
  672.